home *** CD-ROM | disk | FTP | other *** search
/ Aminet 34 / Aminet 34 (2000)(Schatztruhe)[!][Dec 1999].iso / Aminet / dev / lang / Python152_Src.lha / Python152_Source / Python / errors.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-12-22  |  8.8 KB  |  398 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* Error handling */
  33.  
  34. #include "Python.h"
  35.  
  36. #ifdef SYMANTEC__CFM68K__
  37. #pragma lib_export on
  38. #endif
  39.  
  40. #ifdef macintosh
  41. extern char *PyMac_StrError Py_PROTO((int));
  42. #undef strerror
  43. #define strerror PyMac_StrError
  44. #endif /* macintosh */
  45.  
  46. #ifndef __STDC__
  47. #ifndef MS_WINDOWS
  48. extern char *strerror Py_PROTO((int));
  49. #endif
  50. #endif
  51.  
  52. void
  53. PyErr_Restore(type, value, traceback)
  54.     PyObject *type;
  55.     PyObject *value;
  56.     PyObject *traceback;
  57. {
  58.     PyThreadState *tstate = PyThreadState_GET();
  59.     PyObject *oldtype, *oldvalue, *oldtraceback;
  60.  
  61.     if (traceback != NULL && !PyTraceBack_Check(traceback)) {
  62.         /* XXX Should never happen -- fatal error instead? */
  63.         Py_DECREF(traceback);
  64.         traceback = NULL;
  65.     }
  66.  
  67.     /* Save these in locals to safeguard against recursive
  68.        invocation through Py_XDECREF */
  69.     oldtype = tstate->curexc_type;
  70.     oldvalue = tstate->curexc_value;
  71.     oldtraceback = tstate->curexc_traceback;
  72.  
  73.     tstate->curexc_type = type;
  74.     tstate->curexc_value = value;
  75.     tstate->curexc_traceback = traceback;
  76.  
  77.     Py_XDECREF(oldtype);
  78.     Py_XDECREF(oldvalue);
  79.     Py_XDECREF(oldtraceback);
  80. }
  81.  
  82. void
  83. PyErr_SetObject(exception, value)
  84.     PyObject *exception;
  85.     PyObject *value;
  86. {
  87.     Py_XINCREF(exception);
  88.     Py_XINCREF(value);
  89.     PyErr_Restore(exception, value, (PyObject *)NULL);
  90. }
  91.  
  92. void
  93. PyErr_SetNone(exception)
  94.     PyObject *exception;
  95. {
  96.     PyErr_SetObject(exception, (PyObject *)NULL);
  97. }
  98.  
  99. void
  100. PyErr_SetString(exception, string)
  101.     PyObject *exception;
  102.     const char *string;
  103. {
  104.     PyObject *value = PyString_FromString(string);
  105.     PyErr_SetObject(exception, value);
  106.     Py_XDECREF(value);
  107. }
  108.  
  109.  
  110. PyObject *
  111. PyErr_Occurred()
  112. {
  113.     PyThreadState *tstate = PyThreadState_Get();
  114.  
  115.     return tstate->curexc_type;
  116. }
  117.  
  118.  
  119. int
  120. PyErr_GivenExceptionMatches(err, exc)
  121.      PyObject *err, *exc;
  122. {
  123.     if (PyTuple_Check(exc)) {
  124.         int i, n;
  125.         n = PyTuple_Size(exc);
  126.         for (i = 0; i < n; i++) {
  127.             /* Test recursively */
  128.              if (PyErr_GivenExceptionMatches(
  129.                  err, PyTuple_GET_ITEM(exc, i)))
  130.              {
  131.                  return 1;
  132.              }
  133.         }
  134.         return 0;
  135.     }
  136.     /* err might be an instance, so check its class. */
  137.     if (PyInstance_Check(err))
  138.         err = (PyObject*)((PyInstanceObject*)err)->in_class;
  139.  
  140.     if (PyClass_Check(err) && PyClass_Check(exc))
  141.         return PyClass_IsSubclass(err, exc);
  142.  
  143.     return err == exc;
  144. }
  145.     
  146.  
  147. int
  148. PyErr_ExceptionMatches(exc)
  149.      PyObject *exc;
  150. {
  151.     return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
  152. }
  153.  
  154.  
  155. /* Used in many places to normalize a raised exception, including in
  156.    eval_code2(), do_raise(), and PyErr_Print()
  157. */
  158. void
  159. PyErr_NormalizeException(exc, val, tb)
  160.      PyObject **exc;
  161.      PyObject **val;
  162.      PyObject **tb;
  163. {
  164.     PyObject *type = *exc;
  165.     PyObject *value = *val;
  166.     PyObject *inclass = NULL;
  167.  
  168.     /* If PyErr_SetNone() was used, the value will have been actually
  169.        set to NULL.
  170.     */
  171.     if (!value) {
  172.         value = Py_None;
  173.         Py_INCREF(value);
  174.     }
  175.  
  176.     if (PyInstance_Check(value))
  177.         inclass = (PyObject*)((PyInstanceObject*)value)->in_class;
  178.  
  179.     /* Normalize the exception so that if the type is a class, the
  180.        value will be an instance.
  181.     */
  182.     if (PyClass_Check(type)) {
  183.         /* if the value was not an instance, or is not an instance
  184.            whose class is (or is derived from) type, then use the
  185.            value as an argument to instantiation of the type
  186.            class.
  187.         */
  188.         if (!inclass || !PyClass_IsSubclass(inclass, type)) {
  189.             PyObject *args, *res;
  190.  
  191.             if (value == Py_None)
  192.                 args = Py_BuildValue("()");
  193.             else if (PyTuple_Check(value)) {
  194.                 Py_INCREF(value);
  195.                 args = value;
  196.             }
  197.             else
  198.                 args = Py_BuildValue("(O)", value);
  199.  
  200.             if (args == NULL)
  201.                 goto finally;
  202.             res = PyEval_CallObject(type, args);
  203.             Py_DECREF(args);
  204.             if (res == NULL)
  205.                 goto finally;
  206.             Py_DECREF(value);
  207.             value = res;
  208.         }
  209.         /* if the class of the instance doesn't exactly match the
  210.            class of the type, believe the instance
  211.         */
  212.         else if (inclass != type) {
  213.              Py_DECREF(type);
  214.             type = inclass;
  215.             Py_INCREF(type);
  216.         }
  217.     }
  218.     *exc = type;
  219.     *val = value;
  220.     return;
  221. finally:
  222.     Py_DECREF(type);
  223.     Py_DECREF(value);
  224.     Py_XDECREF(*tb);
  225.     PyErr_Fetch(exc, val, tb);
  226.     /* normalize recursively */
  227.     PyErr_NormalizeException(exc, val, tb);
  228. }
  229.  
  230.  
  231. void
  232. PyErr_Fetch(p_type, p_value, p_traceback)
  233.     PyObject **p_type;
  234.     PyObject **p_value;
  235.     PyObject **p_traceback;
  236. {
  237.     PyThreadState *tstate = PyThreadState_Get();
  238.  
  239.     *p_type = tstate->curexc_type;
  240.     *p_value = tstate->curexc_value;
  241.     *p_traceback = tstate->curexc_traceback;
  242.  
  243.     tstate->curexc_type = NULL;
  244.     tstate->curexc_value = NULL;
  245.     tstate->curexc_traceback = NULL;
  246. }
  247.  
  248. void
  249. PyErr_Clear()
  250. {
  251.     PyErr_Restore(NULL, NULL, NULL);
  252. }
  253.  
  254. /* Convenience functions to set a type error exception and return 0 */
  255.  
  256. int
  257. PyErr_BadArgument()
  258. {
  259.     PyErr_SetString(PyExc_TypeError,
  260.             "illegal argument type for built-in operation");
  261.     return 0;
  262. }
  263.  
  264. PyObject *
  265. PyErr_NoMemory()
  266. {
  267.     /* raise the pre-allocated instance if it still exists */
  268.     if (PyExc_MemoryErrorInst)
  269.         PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
  270.     else
  271.         /* this will probably fail since there's no memory and hee,
  272.            hee, we have to instantiate this class
  273.         */
  274.         PyErr_SetNone(PyExc_MemoryError);
  275.  
  276.     return NULL;
  277. }
  278.  
  279. PyObject *
  280. PyErr_SetFromErrnoWithFilename(exc, filename)
  281.     PyObject *exc;
  282.     char *filename;
  283. {
  284.     PyObject *v;
  285.     char *s;
  286.     int i = errno;
  287. #ifdef EINTR
  288.     if (i == EINTR && PyErr_CheckSignals())
  289.         return NULL;
  290. #endif
  291.     if (i == 0)
  292.         s = "Error"; /* Sometimes errno didn't get set */
  293.     else
  294.         s = strerror(i);
  295.     if (filename != NULL && Py_UseClassExceptionsFlag)
  296.         v = Py_BuildValue("(iss)", i, s, filename);
  297.     else
  298.         v = Py_BuildValue("(is)", i, s);
  299.     if (v != NULL) {
  300.         PyErr_SetObject(exc, v);
  301.         Py_DECREF(v);
  302.     }
  303.     return NULL;
  304. }
  305.     
  306.  
  307. PyObject *
  308. PyErr_SetFromErrno(exc)
  309.     PyObject *exc;
  310. {
  311.     return PyErr_SetFromErrnoWithFilename(exc, NULL);
  312. }
  313.  
  314. void
  315. PyErr_BadInternalCall()
  316. {
  317.     PyErr_SetString(PyExc_SystemError,
  318.             "bad argument to internal function");
  319. }
  320.  
  321.  
  322. #ifdef HAVE_STDARG_PROTOTYPES
  323. PyObject *
  324. PyErr_Format(PyObject *exception, const char *format, ...)
  325. #else
  326. PyObject *
  327. PyErr_Format(exception, format, va_alist)
  328.     PyObject *exception;
  329.     const char *format;
  330.     va_dcl
  331. #endif
  332. {
  333.     va_list vargs;
  334.     char buffer[500]; /* Caller is responsible for limiting the format */
  335.  
  336. #ifdef HAVE_STDARG_PROTOTYPES
  337.     va_start(vargs, format);
  338. #else
  339.     va_start(vargs);
  340. #endif
  341.  
  342.     vsprintf(buffer, format, vargs);
  343.     PyErr_SetString(exception, buffer);
  344.     return NULL;
  345. }
  346.  
  347.  
  348. PyObject *
  349. PyErr_NewException(name, base, dict)
  350.     char *name; /* modulename.classname */
  351.     PyObject *base;
  352.     PyObject *dict;
  353. {
  354.     char *dot;
  355.     PyObject *modulename = NULL;
  356.     PyObject *classname = NULL;
  357.     PyObject *mydict = NULL;
  358.     PyObject *bases = NULL;
  359.     PyObject *result = NULL;
  360.     dot = strrchr(name, '.');
  361.     if (dot == NULL) {
  362.         PyErr_SetString(PyExc_SystemError,
  363.             "PyErr_NewException: name must be module.class");
  364.         return NULL;
  365.     }
  366.     if (base == NULL)
  367.         base = PyExc_Exception;
  368.     if (!PyClass_Check(base)) {
  369.         /* Must be using string-based standard exceptions (-X) */
  370.         return PyString_FromString(name);
  371.     }
  372.     if (dict == NULL) {
  373.         dict = mydict = PyDict_New();
  374.         if (dict == NULL)
  375.             goto failure;
  376.     }
  377.     if (PyDict_GetItemString(dict, "__module__") == NULL) {
  378.         modulename = PyString_FromStringAndSize(name, (int)(dot-name));
  379.         if (modulename == NULL)
  380.             goto failure;
  381.         if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
  382.             goto failure;
  383.     }
  384.     classname = PyString_FromString(dot+1);
  385.     if (classname == NULL)
  386.         goto failure;
  387.     bases = Py_BuildValue("(O)", base);
  388.     if (bases == NULL)
  389.         goto failure;
  390.     result = PyClass_New(bases, dict, classname);
  391.   failure:
  392.     Py_XDECREF(bases);
  393.     Py_XDECREF(mydict);
  394.     Py_XDECREF(classname);
  395.     Py_XDECREF(modulename);
  396.     return result;
  397. }
  398.